GridPACK: base_pti_parser.hpp Source File

00001 /*
00002  *     Copyright (c) 2013 Battelle Memorial Institute
00003  *     Licensed under modified BSD License. A copy of this license can be found
00004  *     in the LICENSE file in the top level directory of this distribution.
00005  */
00006 /*
00007  *  Created on: December 30, 2014
00008  *      Author: Kevin Glass, Bruce Palmer
00009  */
00010 
00011 #ifndef BASEPTIPARSER_HPP_
00012 #define BASEPTIPARSER_HPP_
00013 
00014 #define OLD_MAP
00015 
00016 #include <iostream>
00017 #include <string>
00018 #include <vector>
00019 #include <map>
00020 #ifndef OLD_MAP
00021 #include <boost/unordered_map.hpp>
00022 #endif
00023 
00024 
00025 #include "gridpack/component/base_component.hpp"
00026 #include "gridpack/timer/coarse_timer.hpp"
00027 #include "gridpack/component/data_collection.hpp"
00028 #include "gridpack/parser/dictionary.hpp"
00029 #include "gridpack/utilities/exception.hpp"
00030 #include "gridpack/utilities/string_utils.hpp"
00031 #include "gridpack/network/base_network.hpp"
00032 #include "gridpack/parser/base_parser.hpp"
00033 #include "gridpack/parser/hash_distr.hpp"
00034 #include "gridpack/factory/base_factory.hpp"
00035 #include "parser_classes/gencls.hpp"
00036 #include "parser_classes/gensal.hpp"
00037 #include "parser_classes/genrou.hpp"
00038 #include "parser_classes/wsieg1.hpp"
00039 #include "parser_classes/exdc1.hpp"
00040 #include "parser_classes/esst1a.hpp"
00041 #include "parser_classes/esst4b.hpp"
00042 #include "parser_classes/ggov1.hpp"
00043 #include "parser_classes/wshygp.hpp"
00044 #include "parser_classes/lvshbl.hpp"
00045 #include "parser_classes/frqtpat.hpp"
00046 #include "parser_classes/distr1.hpp"
00047 #include "parser_classes/cim6bl.hpp"
00048 #include "parser_classes/acmtblu1.hpp"
00049 #include "parser_classes/ieelbl.hpp"
00050 #include "parser_classes/cmldblu1.hpp"
00051 #include "parser_classes/psssim.hpp"
00052 
00053 namespace gridpack {
00054 namespace parser {
00055 
00056 template <class _network>
00057 class BasePTIParser : public BaseParser<_network>
00058 {
00059   public:
00060 
00061     /**
00062      * Constructor
00063      */
00064     explicit BasePTIParser()
00065     {
00066       p_timer = gridpack::utility::CoarseTimer::instance();
00067     }
00068 
00069 
00070     /**
00071      * Destructor
00072      */
00073     virtual ~BasePTIParser(){}
00074 
00075     /**
00076      * Parse a second file after original network has been distributed. This
00077      * requires the data in the second file to be distributed to all network
00078      * objects that need the data
00079      * @param fileName name of file
00080      */
00081     void externalParse(const std::string &fileName)
00082     {
00083       std::string ext = getExtension(fileName);
00084       if (ext == "dyr") {
00085         getDSExternal(fileName);
00086         expandBusModels();
00087       } else if (ext == "uc") {
00088         getUCExternal(fileName);
00089       }
00090     }
00091 
00092     /**
00093      * Expand any compound bus models that may need to be generated based on
00094      * parameters in the .dyr files. This function needs to be called after
00095      * calling the parser for the .dyr file
00096      */
00097     void expandBusModels(void)
00098     {
00099       // Find maximum original bus index. This value can be used to assign
00100       // indices to new buses generated by expanding the model
00101       int max_idx = -1;
00102       int nbus = p_network->numBuses();
00103       int totalBuses = p_network->totalBuses();
00104       int totalBranches = p_network->totalBranches();
00105       int i, j;
00106       for (i=0; i<nbus; i++) {
00107         if (p_network->getActiveBus(i)) {
00108           if (max_idx < p_network->getOriginalBusIndex(i)) {
00109             max_idx = p_network->getOriginalBusIndex(i);
00110           }
00111         }
00112       }
00113       p_network->communicator().max(&max_idx,1);
00114 
00115       // Create new data collection objects corresponding to new buses and
00116       // branches for the expanded composite load
00117       std::vector<std::vector<gridpack::component::DataCollection*> >
00118         new_buses;
00119       std::vector<std::vector<gridpack::component::DataCollection*> >
00120         new_branches;
00121       gridpack::component::DataCollection *data;
00122       std::string model;
00123       int nload;
00124       std::vector<int> comp_buses;
00125       for (i=0; i<nbus; i++) {
00126         // Only expand bus on process that owns bus. New buses and branches will
00127         // not have connections to other processors
00128         if (p_network->getActiveBus(i)) {
00129          data = p_network->getBusData(i).get();
00130          if (data->getValue(LOAD_NUMBER,&nload)) {
00131            for (j=0; j<nload; j++) {
00132              if (data->getValue(LOAD_MODEL,&model, j)) {
00133                if (model == "CMLDBLU1") {
00134                  std::vector<gridpack::component::DataCollection*> buses;
00135                  std::vector<gridpack::component::DataCollection*> branches;
00136                  Cmldblu1Parser<load_params> parser;
00137                  parser.expandModel(data, buses, branches, j);
00138                  new_buses.push_back(buses);
00139                  new_branches.push_back(branches);
00140                  comp_buses.push_back(i);
00141                }
00142              }
00143            }
00144          }
00145         }
00146       }
00147       // Check to see if there actually are any buses to expand. If not, quit
00148       // now.
00149       int ncomp = comp_buses.size();
00150       p_network->communicator().sum(&ncomp,1);
00151       if (ncomp == 0) return;
00152 
00153       // Find new indices for the buses. Start by finding out how many new buses
00154       // have been added to the system
00155       int nprocs = p_network->communicator().size();
00156       int me = p_network->communicator().rank();
00157       std::vector<int> added_buses(nprocs);
00158       for (i=0; i<nprocs; i++) {
00159         added_buses[i] = 0;
00160       }
00161       int numLoads = new_buses.size();
00162       // Subtract 1 because bus 0 corresponds to the original bus and
00163       // already has an index
00164       for (i=0; i<numLoads; i++) {
00165         added_buses[me] += new_buses[i].size()-1;
00166       }
00167       p_network->communicator().sum(&added_buses[0],nprocs);
00168       std::vector<int> offset(nprocs);
00169       offset[0] = 0;
00170       for (i=1; i<nprocs; i++) {
00171         offset[i] = offset[i-1] + added_buses[i-1];
00172       }
00173       // Assign new original indices to the new buses
00174       int icnt = 0;
00175       int idx;
00176       std::vector<std::vector<int> > local_bus;
00177       for (i=0; i<numLoads; i++) {
00178         std::vector<int> lidx;
00179         lidx.push_back(comp_buses[i]);
00180         for (j=1; j<new_buses[i].size(); j++) {
00181           data = (new_buses[i])[j];
00182           idx = offset[me]+icnt+max_idx+1;
00183           data->addValue(BUS_NUMBER, idx);
00184           p_network->addBus(idx);
00185           *(p_network->getBusData(nbus+icnt))
00186             = *data;
00187           p_network->setActiveBus(nbus+icnt,true);
00188           lidx.push_back(nbus+icnt);
00189           icnt++;
00190         }
00191         local_bus.push_back(lidx);
00192       }
00193       // New buses now have original IDs and are complete.
00194       // Now need to set "from" and "to"
00195       // indices for new branches as well as fixing up neighor lists
00196       int from, to, i1, i2;
00197       icnt = 0;
00198       int nbranch = p_network->numBranches();
00199       for (i=0; i<numLoads; i++) {
00200         for (j=0; j<new_branches[i].size(); j++) {
00201           // Assign new bus IDs to new branches
00202           data = (new_branches[i])[j];
00203           data->getValue(BRANCH_FROMBUS,&from);
00204           data->getValue(BRANCH_TOBUS,&to);
00205           (new_buses[i])[from]->getValue(BUS_NUMBER, &i1);
00206           (new_buses[i])[to]->getValue(BUS_NUMBER, &i2);
00207           data->setValue(BRANCH_FROMBUS,i1);
00208           data->setValue(BRANCH_TOBUS,i2);
00209           p_network->addBranch(i1,i2);
00210           *(p_network->getBranchData(nbranch+icnt))
00211             = *data;
00212           p_network->setActiveBranch(nbranch+icnt,true);
00213           // Modify neighbor lists etc to account for new buses
00214           p_network->setLocalBusIndex1(nbranch+icnt,(local_bus[i])[from]);
00215           p_network->setLocalBusIndex2(nbranch+icnt,(local_bus[i])[to]);
00216           p_network->addBranchNeighbor((local_bus[i])[from],nbranch+icnt);
00217           p_network->addBranchNeighbor((local_bus[i])[to],nbranch+icnt);
00218           icnt++;
00219         }
00220       }
00221       // Completely reset global indices
00222       p_network->resetGlobalIndices(true);
00223 #if 0
00224       // Assign global indices to new buses.
00225       icnt = 0;
00226       int lcnt = 0;
00227       // loop over original buses
00228       for (i=0; i<nbus; i++) {
00229         if (p_network->getActiveBus(i)) {
00230           if (i == comp_buses[icnt]) {
00231             // if original bus is composite bus, loop over new buses;
00232             for (j=1; j<local_bus[icnt].size(); j++) {
00233               p_network->setGlobalBusIndex((local_bus[icnt])[j],
00234                   totalBuses+offset[me]+lcnt);
00235               lcnt++;
00236             }
00237             icnt++;
00238           }
00239         }
00240       }
00241 
00242       // Add global indices to new local branches.
00243       int nbranch_new = p_network->numBranches();
00244       std::vector<int> branch_buf(nprocs);
00245       for (i=0; i<nprocs; i++) {
00246         branch_buf[i] = 0;
00247       }
00248       branch_buf[me] = nbranch_new-nbranch;
00249       p_network->communicator().sum(&branch_buf[0],nprocs);
00250       offset[0] = 0;
00251       for (i=1; i<nprocs; i++) {
00252         offset[i] = offset[i-1]+branch_buf[i-1];
00253       }
00254       icnt = offset[me];
00255       for (i=nbranch; i<nbranch_new; i++) {
00256         if (p_network->getActiveBranch(i)) {
00257           p_network->setGlobalBranchIndex(i,totalBranches+icnt);
00258           icnt++;
00259         }
00260       }
00261 
00262       // Reset remaining indices
00263       p_network->resetGlobalIndices(false);
00264 #endif
00265       gridpack::factory::BaseFactory<_network> factory(p_network);
00266       factory.setComponents();
00267     }
00268 
00269     /**
00270      * Change the sign of the BRANCH_SHIFT variable. The sign convention
00271      * for this variable is not consistent across different files
00272      */
00273     void changePhaseShiftSign()
00274     {
00275       int i, j, nelems;
00276       double rval;
00277       boost::shared_ptr<gridpack::component::DataCollection> data;
00278       int nbranch = p_network->numBranches();
00279       for (i=0; i<nbranch; i++) {
00280         data = p_network->getBranchData(i);
00281         data->getValue(BRANCH_NUM_ELEMENTS,&nelems);
00282         for (j=0; j<nelems; j++) {
00283           if (data->getValue(BRANCH_SHIFT,&rval,j)) {
00284             rval *= -1.0;
00285             data->setValue(BRANCH_SHIFT,rval,j);
00286           }
00287         }
00288       }
00289     }
00290 
00291   protected:
00292 
00293     /* ************************************************************************
00294      **************************************************************************
00295      ***** PROTECTED SCOPE
00296      **************************************************************************
00297      *********************************************************************** */
00298 
00299     /**
00300      * Assign network to internal network pointer variable
00301      */
00302     void setNetwork(boost::shared_ptr<_network> network)
00303     {
00304       p_network = network;
00305       p_network_data = network->getNetworkData();
00306       BaseParser<_network>::setNetwork(network);
00307     }
00308 
00309     /**
00310      * This routine opens up a .dyr file with parameters for dynamic
00311      * simulation. It assumes that a .raw file has already been parsed
00312      */
00313     void getDS(const std::string & fileName)
00314     {
00315       int t_ds = p_timer->createCategory("Parser:getDS");
00316       p_timer->start(t_ds);
00317       int me(p_network->communicator().rank());
00318 
00319       if (me == 0) {
00320         std::ifstream input;
00321         input.open(fileName.c_str());
00322         if (!input.is_open()) {
00323           p_timer->stop(t_ds);
00324           return;
00325         }
00326         find_ds_par(input);
00327         input.close();
00328       }
00329       p_timer->stop(t_ds);
00330 #if 0
00331       int i;
00332       printf("BUS data size: %d\n",p_busData.size());
00333       for (i=0; i<p_network->numBuses(); i++) {
00334         printf("Dumping bus: %d\n",i);
00335         p_network->getBusData(i)->dump();
00336       }
00337 #endif
00338     }
00339 
00340     // Data structure to hold generator params
00341     struct gen_params{
00342       // Generator parameters
00343       int bus_id; // ID of bus that owns device
00344       char model[8];  // Model represented by data
00345       char gen_id[3]; // Generator ID
00346       double inertia;  // Inertia constant 0
00347       double damping;  // Damping coefficient
00348       double reactance; // Transient reactance
00349       double tdop;
00350       double tdopp;
00351       double tqop;
00352       double tqopp;
00353       double gn_xd;
00354       double gn_xq;
00355       double xdp;
00356       double xqp;
00357       double xdpp;
00358       double gn_xl;
00359       double gn_s1;
00360       double s12;
00361       // Exciter parameters
00362       bool has_exciter;
00363       double ex_tr;
00364       double ex_ka;
00365       double ex_ta;
00366       double ex_tb;
00367       double ex_tc;
00368       double vrmax;
00369       double vrmin;
00370       double ex_ke;
00371       double ex_te;
00372       double ex_kf;
00373       double tf1;
00374       double rswitch;
00375       double ex_e1;
00376       double se1;
00377       double ex_e2;
00378       double se2;
00379       double uel;
00380       double vos;
00381       double vimax;
00382       double vimin;
00383       double tc1;
00384       double tb1;
00385       double vamax;
00386       double vamin;
00387       double ex_kc;
00388       double ex_tf;
00389       double klr;
00390       double ilr;
00391       double kpr;
00392       double kir;
00393       double kpm;
00394       double kim;
00395       double vmmax;
00396       double vmmin;
00397       double ex_kg;
00398       double ex_kp;
00399       double ex_ki;
00400       double vbmax;
00401       double ex_xl;
00402       double thetap;
00403       // Governor parameters
00404       bool has_governor;
00405       int jbus;
00406       int gv_m;
00407       double gv_k;
00408       double gv_t1;
00409       double gv_t2;
00410       double gv_t3;
00411       double gv_uo;
00412       double gv_uc;
00413       double pmax;
00414       double pmin;
00415       double gv_t4;
00416       double gv_k1;
00417       double gv_k2;
00418       double gv_t5;
00419       double gv_k3;
00420       double gv_k4;
00421       double gv_t6;
00422       double gv_k5;
00423       double gv_k6;
00424       double gv_t7;
00425       double gv_k7;
00426       double gv_k8;
00427       double db1;
00428       double err;
00429       double db2;
00430       double gv1;
00431       double pgv1;
00432       double gv2;
00433       double pgv2;
00434       double gv3;
00435       double pgv3;
00436       double gv4;
00437       double pgv4;
00438       double gv5;
00439       double pgv5;
00440       int iblock;
00441       double rselect;
00442       double flagswitch;
00443       double gv_r;
00444       double tpelec;
00445       double maxerr;
00446       double minerr;
00447       double kpgov;
00448       double kigov;
00449       double kdgov;
00450       double tdgov;
00451       double vmax;
00452       double vmin;
00453       double tact;
00454       double kturb;
00455       double wfnl;
00456       double gv_tb;
00457       double gv_tc;
00458       double teng;
00459       double tfload;
00460       double kpload;
00461       double kiload;
00462       double ldref;
00463       double gv_dm;
00464       double ropen;
00465       double rclose;
00466       double kimw;
00467       double aset;
00468       double gv_ka;
00469       double gv_ta;
00470       double trate;
00471       double gv_db;
00472       double tsa;
00473       double tsb;
00474       double rup;
00475       double rdown;
00476       double gv_td;
00477       double gv_ki;
00478       double gv_tf;
00479       double gv_kd;
00480       double gv_kp;
00481       double gv_tt;
00482       double gv_kg;
00483       double gv_tp;
00484       double velopen;
00485       double velclose;
00486       double aturb;
00487       double bturb;
00488       double tturb;
00489       // PSSSIM parameters
00490       int psssim_inputtype;
00491       int psssim_bus1;
00492       int psssim_bus2;
00493       int psssim_bus3;
00494       int psssim_bus4;
00495       int psssim_bus5;
00496       int psssim_bus6;
00497       double psssim_gaink;
00498       double psssim_tw;
00499       double psssim_t1;
00500       double psssim_t2;
00501       double psssim_t3;
00502       double psssim_t4;
00503       double psssim_maxout;
00504       double psssim_minout;
00505     };
00506 
00507     // Data structure to hold relay parameters on buses
00508     struct bus_relay_params{
00509       int bus_id; // ID of bus that owns device
00510       char model[8];  // Model represented by data
00511       char tag[3]; //
00512       int jbus;
00513       int mins;
00514       int frebus;
00515       double v1;
00516       double t1;
00517       double f1;
00518       double v2;
00519       double t2;
00520       double f2;
00521       double v3;
00522       double t3;
00523       double f3;
00524       double tb;
00525       double fl;
00526       double fu;
00527       double tp;
00528     };
00529 
00530     // Data structure to hold relay parameters on branches
00531     struct branch_relay_params{
00532       int from_bus; // ID of from bus
00533       int to_bus; // ID of to bus
00534       char model[8];  // Model represented by data
00535       char id[3];
00536       char id1[3];
00537       char id2[3];
00538       char id3[3];
00539       int ibus;
00540       int jbus;
00541       int ibus1;
00542       int jbus1;
00543       int ibus2;
00544       int jbus2;
00545       int ibus3;
00546       int jbus3;
00547       int rs;
00548       int mtype;
00549       int bmon;
00550       int bltype1;
00551       int bltype2;
00552       double zone1_time;
00553       double zone1_reach;
00554       double zone1_cenang;
00555       double zone1_cendis;
00556       double zone2_time;
00557       double zone2_reach;
00558       double zone2_cenang;
00559       double zone2_cendis;
00560       double zone3_time;
00561       double zone3_reach;
00562       double zone3_cenang;
00563       double zone3_cendis;
00564       double dirang;
00565       double thcur;
00566       double sebtime;
00567       double serctime;
00568       double trbtime;
00569       double trrctime;
00570       double blint1;
00571       double blro1;
00572       double blint2;
00573       double blro2;
00574     };
00575 
00576     // Data structure to hold parameters for conventional loads
00577     struct load_params{
00578       int bus_id; // ID of bus that owns load
00579       char model[9];  // Model represented by data
00580       char id[3]; // Load ID
00581       int it;
00582       double ra;
00583       double xa;
00584       double xm;
00585       double r1;
00586       double x1;
00587       double r2;
00588       double x2;
00589       double e1;
00590       double se1;
00591       double e2;
00592       double se2;
00593       double mbase;
00594       double pmult;
00595       double h;
00596       double vi;
00597       double ti;
00598       double tb;
00599       double a;
00600       double b;
00601       double d;
00602       double e;
00603       double c0;
00604       double tnom;
00605 
00606       double tstall;
00607       double trestart;
00608       double tv;
00609       double tf;
00610       double complf;
00611       double comppf;
00612       double vstall;
00613       double rstall;
00614       double xstall;
00615       double lfadj;
00616       double kp1;
00617       double np1;
00618       double kq1;
00619       double nq1;
00620       double kp2;
00621       double np2;
00622       double kq2;
00623       double nq2;
00624       double vbrk;
00625       double frst;
00626       double vrst;
00627       double cmpkpf;
00628       double cmpkqf;
00629       double vc1off;
00630       double vc2off;
00631       double vc1on;
00632       double vc2on;
00633       double tth;
00634       double th1t;
00635       double th2t;
00636       double fuvr;
00637       double uvtr1;
00638       double ttr1;
00639       double uvtr2;
00640       double ttr2;
00641 
00642       double a1;
00643       double a2;
00644       double a3;
00645       double a4;
00646       double a5;
00647       double a6;
00648       double a7;
00649       double a8;
00650       double n1;
00651       double n2;
00652       double n3;
00653       double n4;
00654       double n5;
00655       double n6;
00656 
00657       double mva;
00658       double bss;
00659       double rfdr;
00660       double xfdr;
00661       double fb;
00662       double xxf;
00663       double tfixhs;
00664       double tfixls;
00665       double ltc;
00666       double tmin;
00667       double tmax;
00668       double step;
00669       double vmin;
00670       double vmax;
00671       double tdel;
00672       double ttap;
00673       double rcomp;
00674       double xcomp;
00675       double fma;
00676       double fmb;
00677       double fmc;
00678       double fmd;
00679       double fel;
00680       double pfel;
00681       double vd1;
00682       double vd2;
00683       double pfs;
00684       double p1e;
00685       double p1c;
00686       double p2e;
00687       double p2c;
00688       double pfreq;
00689       double q1e;
00690       double q1c;
00691       double q2e;
00692       double q2c;
00693       double qfreq;
00694 
00695       int mtpa;
00696       double lfma;
00697       double rsa;
00698       double lsa;
00699       double lpa;
00700       double lppa;
00701       double tpoa;
00702       double tppoa;
00703       double ha;
00704       double etrqa;
00705       double vtr1a;
00706       double ttr1a;
00707       double ftr1a;
00708       double vrc1a;
00709       double trc1a;
00710       double vtr2a;
00711       double ttr2a;
00712       double ftr2a;
00713       double vrc2a;
00714       double trc2a;
00715 
00716       int mtpb;
00717       double lfmb;
00718       double rsb;
00719       double lsb;
00720       double lpb;
00721       double lppb;
00722       double tpob;
00723       double tppob;
00724       double hb;
00725       double etrqb;
00726       double vtr1b;
00727       double ttr1b;
00728       double ftr1b;
00729       double vrc1b;
00730       double trc1b;
00731       double vtr2b;
00732       double ttr2b;
00733       double ftr2b;
00734       double vrc2b;
00735       double trc2b;
00736 
00737       int mtpc;
00738       double lfmc;
00739       double rsc;
00740       double lsc;
00741       double lpc;
00742       double lppc;
00743       double tpoc;
00744       double tppoc;
00745       double hc;
00746       double etrqc;
00747       double vtr1c;
00748       double ttr1c;
00749       double ftr1c;
00750       double vrc1c;
00751       double trc1c;
00752       double vtr2c;
00753       double ttr2c;
00754       double ftr2c;
00755       double vrc2c;
00756       double trc2c;
00757 
00758       int mtpd;
00759       double lfmd;
00760       double trst;
00761       double vtr1;
00762       double vtr2;
00763     };
00764 
00765     /**
00766      * This routine opens up a .dyr file with parameters for dynamic
00767      * simulation and distributes the parameters to whatever processor holds the
00768      * corresponding buses. It assumes that a .raw file has already been parsed
00769      */
00770     void getDSExternal(const std::string & fileName)
00771     {
00772 
00773       //      int t_ds = p_timer->createCategory("Parser:getDS");
00774       //      p_timer->start(t_ds);
00775       int me(p_network->communicator().rank());
00776 
00777       std::vector<gen_params> gen_data;
00778       std::vector<bus_relay_params> bus_relay_data;
00779       std::vector<branch_relay_params> branch_relay_data;
00780       std::vector<load_params> load_data;
00781       if (me == 0) {
00782         std::ifstream            input;
00783         input.open(fileName.c_str());
00784         if (!input.is_open()) {
00785           // p_timer->stop(t_ds);
00786           return;
00787         }
00788         find_ds_vector(input, &gen_data, &bus_relay_data,
00789             &branch_relay_data, &load_data);
00790         input.close();
00791       }
00792       int nsize = gen_data.size();
00793       std::vector<int> buses;
00794       int i;
00795       for (i=0; i<nsize; i++) {
00796         buses.push_back(gen_data[i].bus_id);
00797       }
00798       gridpack::hash_distr::HashDistribution<_network,gen_params,gen_params>
00799         distr(p_network);
00800       distr.distributeBusValues(buses,gen_data);
00801       // Now match data with corresponding data collection objects
00802       gridpack::component::DataCollection *data;
00803       nsize = buses.size();
00804       for (i=0; i<nsize; i++) {
00805         int l_idx = buses[i];
00806         data = dynamic_cast<gridpack::component::DataCollection*>
00807           (p_network->getBusData(l_idx).get());
00808 
00809         // Find out how many generators are already on bus
00810         int ngen = 0;
00811         data->getValue(GENERATOR_NUMBER, &ngen);
00812         // Identify index of generator to which this data applies
00813         int g_id = -1;
00814         if (ngen > 0) {
00815           // Clean up 2 character tag for generator ID
00816           std::string tag = gen_data[i].gen_id;
00817           int j;
00818           for (j=0; j<ngen; j++) {
00819             std::string t_id;
00820             data->getValue(GENERATOR_ID,&t_id,j);
00821             if (tag == t_id) {
00822               g_id = j;
00823               break;
00824             }
00825           }
00826         }
00827 
00828         // Check to see parameters can be assigned to a generator
00829         if (g_id > -1) {
00830           if (!strcmp(gen_data[i].model,"GENCLS")) {
00831             GenclsParser<gen_params> parser;
00832             parser.extract(gen_data[i], data, g_id);
00833           } else if (!strcmp(gen_data[i].model,"GENSAL")) {
00834             GensalParser<gen_params> parser;
00835             parser.extract(gen_data[i], data, g_id);
00836           } else if (!strcmp(gen_data[i].model,"GENROU")) {
00837             GenrouParser<gen_params> parser;
00838             parser.extract(gen_data[i], data, g_id);
00839           } else if (!strcmp(gen_data[i].model,"WSIEG1")) {
00840             Wsieg1Parser<gen_params> parser;
00841             parser.extract(gen_data[i], data, g_id);
00842           } else if (!strcmp(gen_data[i].model,"EXDC1") ||
00843               !strcmp(gen_data[i].model,"EXDC2")) {
00844             Exdc1Parser<gen_params> parser;
00845             parser.extract(gen_data[i], data, g_id);
00846           } else if (!strcmp(gen_data[i].model,"ESST1A")) {
00847             Esst1aParser<gen_params> parser;
00848             parser.extract(gen_data[i], data, g_id);
00849           } else if (!strcmp(gen_data[i].model,"ESST4B")) {
00850             Esst4bParser<gen_params> parser;
00851             parser.extract(gen_data[i], data, g_id);
00852           } else if (!strcmp(gen_data[i].model,"GGOV1")) {
00853             Ggov1Parser<gen_params> parser;
00854             parser.extract(gen_data[i], data, g_id);
00855           } else if (!strcmp(gen_data[i].model,"WSHYGP")) {
00856             WshygpParser<gen_params> parser;
00857             parser.extract(gen_data[i], data, g_id);
00858           } else if (!strcmp(gen_data[i].model,"PSSSIM")) {
00859             PsssimParser<gen_params> parser;
00860             parser.extract(gen_data[i], data, g_id);
00861           }
00862         }
00863       }
00864       // Add parameters for a bus relay
00865       nsize = bus_relay_data.size();
00866       buses.clear();
00867       for (i=0; i<nsize; i++) {
00868         buses.push_back(bus_relay_data[i].bus_id);
00869       }
00870       gridpack::hash_distr::HashDistribution<_network,bus_relay_params,
00871         bus_relay_params> distr_bus(p_network);
00872       distr_bus.distributeBusValues(buses,bus_relay_data);
00873       // Now match data with corresponding data collection objects
00874       nsize = buses.size();
00875       for (i=0; i<nsize; i++) {
00876         int l_idx = buses[i];
00877         data = dynamic_cast<gridpack::component::DataCollection*>
00878           (p_network->getBusData(l_idx).get());
00879         // Add relay data to bus
00880         if (!strcmp(bus_relay_data[i].model,"LVSHBL")) {
00881           LvshblParser<bus_relay_params> parser;
00882           parser.extract(bus_relay_data[i], data);
00883         } else if (!strcmp(bus_relay_data[i].model,"FRQTPAT")) {
00884           FrqtpatParser<bus_relay_params> parser;
00885           parser.extract(bus_relay_data[i], data);
00886         }
00887       }
00888       buses.clear();
00889       // Add parameters for a branch relay
00890       nsize = branch_relay_data.size();
00891       std::vector<std::pair<int,int> > branches;
00892       std::vector<int> lbranch;
00893       for (i=0; i<nsize; i++) {
00894         branches.push_back(std::pair<int,int>(branch_relay_data[i].from_bus,
00895               branch_relay_data[i].to_bus));
00896       }
00897       gridpack::hash_distr::HashDistribution<_network,branch_relay_params,
00898         branch_relay_params> distr_branch(p_network);
00899       distr_branch.distributeBranchValues(branches,lbranch,branch_relay_data);
00900       // Now match data with corresponding data collection objects
00901       nsize = lbranch.size();
00902       for (i=0; i<nsize; i++) {
00903         int l_idx = lbranch[i];
00904         data = dynamic_cast<gridpack::component::DataCollection*>
00905           (p_network->getBranchData(l_idx).get());
00906         // Add relay data to branch
00907         if (!strcmp(branch_relay_data[i].model,"DISTR1")) {
00908           Distr1Parser<branch_relay_params> parser;
00909           parser.extract(branch_relay_data[i], data);
00910         }
00911       }
00912 
00913       // Add parameters for a load
00914       nsize = load_data.size();
00915       buses.clear();
00916       for (i=0; i<nsize; i++) {
00917         buses.push_back(load_data[i].bus_id);
00918       }
00919       gridpack::hash_distr::HashDistribution<_network,load_params,
00920         load_params> distr_load(p_network);
00921       distr_load.distributeBusValues(buses,load_data);
00922       // Now match data with corresponding data collection objects
00923       nsize = buses.size();
00924       for (i=0; i<nsize; i++) {
00925         int l_idx = buses[i];
00926         data = dynamic_cast<gridpack::component::DataCollection*>
00927           (p_network->getBusData(l_idx).get());
00928 
00929         // Find out how many loads are already on bus
00930         int nload = 0;
00931         data->getValue(LOAD_NUMBER, &nload);
00932         // Identify index of load to which this data applies
00933         int l_id = -1;
00934         if (nload > 0) {
00935           // Clean up 2 character tag for generator ID
00936           std::string tag = load_data[i].id;
00937           int j;
00938           for (j=0; j<nload; j++) {
00939             std::string t_id;
00940             data->getValue(LOAD_ID,&t_id,j);
00941             if (tag == t_id) {
00942               l_id = j;
00943               break;
00944             }
00945           }
00946         }
00947 
00948         // Assign parameters to a load
00949         if (l_id > -1) {
00950           if (!strcmp(load_data[i].model,"CIM6BL")) {
00951             Cim6blParser<load_params> parser;
00952             parser.extract(load_data[i], data, l_id);
00953           } else if (!strcmp(load_data[i].model,"IEELBL")) {
00954             IeelblParser<load_params> parser;
00955             parser.extract(load_data[i], data, l_id);
00956           } else if (!strcmp(load_data[i].model,"ACMTBLU1")) {
00957             Acmtblu1Parser<load_params> parser;
00958             parser.extract(load_data[i], data, l_id);
00959           } else if (!strcmp(load_data[i].model,"CMLDBLU1")) {
00960             Cmldblu1Parser<load_params> parser;
00961             parser.extract(load_data[i], data, l_id);
00962           }
00963         } else {
00964           printf("No match found for load on bus %d with tag %s\n",
00965               load_data[i].bus_id,load_data[i].id);
00966         }
00967       }
00968     }
00969 
00970     struct uc_params{
00971       int bus_id; // ID of bus that owns generator
00972       char gen_id[3]; // Generator ID
00973       int type;
00974       double init_level; // Initial production level
00975       double min_gen; // Minimum generation
00976       double max_gen; // Maximum generation
00977       double max_oper; // Maximum operating generation
00978       double min_up;
00979       double min_down;
00980       double ramp_up;
00981       double ramp_down;
00982       double start_up; // Start up cost
00983       double const_cost; // Constant cost
00984       double lin_cost; // Linear cost
00985       double co_2_cost;
00986       double init_prd; // Init periods
00987       double start_cap; // Startup cap
00988       double shut_cap; // Shutdown cap
00989     };
00990 
00991     /**
00992      * This routine opens up a .uc file with parameters for a unit commitment
00993      * calculationand distributes the parameters to whatever processor holds the
00994      * corresponding buses. It assumes that a .raw file has already been parsed
00995      */
00996     void getUCExternal(const std::string & fileName)
00997     {
00998 
00999       int me(p_network->communicator().rank());
01000 
01001       std::vector<uc_params> uc_data;
01002       if (me == 0) {
01003         std::ifstream            input;
01004         input.open(fileName.c_str());
01005         if (!input.is_open()) {
01006           return;
01007         }
01008         find_uc_vector(input, &uc_data);
01009         input.close();
01010       }
01011       int nsize = uc_data.size();
01012       std::vector<int> buses;
01013       int i;
01014       for (i=0; i<nsize; i++) {
01015         buses.push_back(uc_data[i].bus_id);
01016       }
01017       gridpack::hash_distr::HashDistribution<_network,uc_params,uc_params>
01018         distr(p_network);
01019       distr.distributeBusValues(buses,uc_data);
01020       // Now match data with corresponding data collection objects
01021       gridpack::component::DataCollection *data;
01022       nsize = buses.size();
01023       for (i=0; i<nsize; i++) {
01024         int l_idx = buses[i];
01025         data = dynamic_cast<gridpack::component::DataCollection*>
01026           (p_network->getBusData(l_idx).get());
01027 
01028         // Find out how many generators are already on bus
01029         int ngen;
01030         if (!data->getValue(GENERATOR_NUMBER, &ngen)) continue;
01031         // Identify index of generator to which this data applies
01032         int g_id = -1;
01033         // Clean up 2 character tag for generator ID
01034         std::string tag = uc_data[i].gen_id;
01035         int j;
01036         for (j=0; j<ngen; j++) {
01037           std::string t_id;
01038           data->getValue(GENERATOR_ID,&t_id,j);
01039           if (tag == t_id) {
01040             g_id = j;
01041             break;
01042           }
01043         }
01044         if (g_id == -1) continue;
01045 
01046         double rval;
01047         int ival;
01048         if (!data->getValue("GENERATOR_TYPE",&ival,g_id)) {
01049           data->addValue("GENERATOR_TYPE", uc_data[i].type, g_id);
01050         } else {
01051           data->setValue("GENERATOR_TYPE", uc_data[i].type, g_id);
01052         }
01053 
01054         if (!data->getValue("GENERATOR_INIT_LEVEL",&rval,g_id)) {
01055           data->addValue("GENERATOR_INIT_LEVEL", uc_data[i].init_level, g_id);
01056         } else {
01057           data->setValue("GENERATOR_INIT_LEVEL", uc_data[i].init_level, g_id);
01058         }
01059 
01060         if (!data->getValue("GENERATOR_MIN_GEN",&rval,g_id)) {
01061           data->addValue("GENERATOR_MIN_GEN", uc_data[i].min_gen, g_id);
01062         } else {
01063           data->setValue("GENERATOR_MIN_GEN", uc_data[i].min_gen, g_id);
01064         }
01065 
01066         if (!data->getValue("GENERATOR_MAX_GEN",&rval,g_id)) {
01067           data->addValue("GENERATOR_MAX_GEN", uc_data[i].max_gen, g_id);
01068         } else {
01069           data->setValue("GENERATOR_MAX_GEN", uc_data[i].max_gen, g_id);
01070         }
01071 
01072         if (!data->getValue("GENERATOR_MAX_OP_GEN",&rval,g_id)) {
01073           data->addValue("GENERATOR_MAX_OP_GEN", uc_data[i].max_gen, g_id);
01074         } else {
01075           data->setValue("GENERATOR_MAX_OP_GEN", uc_data[i].max_gen, g_id);
01076         }
01077         if (!data->getValue("GENERATOR_MIN_UP",&rval,g_id)) {
01078           data->addValue("GENERATOR_MIN_UP", uc_data[i].min_up, g_id);
01079         } else {
01080           data->setValue("GENERATOR_MIN_UP", uc_data[i].min_up, g_id);
01081         }
01082 
01083         if (!data->getValue("GENERATOR_MIN_DOWN",&rval,g_id)) {
01084           data->addValue("GENERATOR_MIN_DOWN", uc_data[i].min_down, g_id);
01085         } else {
01086           data->setValue("GENERATOR_MIN_DOWN", uc_data[i].min_down, g_id);
01087         }
01088 
01089         if (!data->getValue("GENERATOR_RAMP_UP",&rval,g_id)) {
01090           data->addValue("GENERATOR_RAMP_UP", uc_data[i].ramp_up, g_id);
01091         } else {
01092           data->setValue("GENERATOR_RAMP_UP", uc_data[i].ramp_up, g_id);
01093         }
01094 
01095         if (!data->getValue("GENERATOR_RAMP_DOWN",&rval,g_id)) {
01096           data->addValue("GENERATOR_RAMP_DOWN", uc_data[i].ramp_down, g_id);
01097         } else {
01098           data->setValue("GENERATOR_RAMP_DOWN", uc_data[i].ramp_down, g_id);
01099         }
01100 
01101         if (!data->getValue("GENERATOR_START_UP",&rval,g_id)) {
01102           data->addValue("GENERATOR_START_UP", uc_data[i].start_up, g_id);
01103         } else {
01104           data->setValue("GENERATOR_START_UP", uc_data[i].start_up, g_id);
01105         }
01106 
01107         if (!data->getValue("GENERATOR_CONST_COST",&rval,g_id)) {
01108           data->addValue("GENERATOR_CONST_COST", uc_data[i].const_cost, g_id);
01109         } else {
01110           data->setValue("GENERATOR_CONST_COST", uc_data[i].const_cost, g_id);
01111         }
01112         if (!data->getValue("GENERATOR_LIN_COST",&rval,g_id)) {
01113           data->addValue("GENERATOR_LIN_COST", uc_data[i].lin_cost, g_id);
01114         } else {
01115           data->setValue("GENERATOR_LIN_COST", uc_data[i].lin_cost, g_id);
01116         }
01117         if (!data->getValue("GENERATOR_CO_2_COST",&rval,g_id)) {
01118           data->addValue("GENERATOR_CO_2_COST", uc_data[i].co_2_cost, g_id);
01119         } else {
01120           data->setValue("GENERATOR_CO_2_COST", uc_data[i].co_2_cost, g_id);
01121         }
01122 
01123         if (!data->getValue("GENERATOR_INIT_PRD",&rval,g_id)) {
01124           data->addValue("GENERATOR_INIT_PRD", uc_data[i].init_prd, g_id);
01125         } else {
01126           data->setValue("GENERATOR_INIT_PRD", uc_data[i].init_prd, g_id);
01127         }
01128 
01129         if (!data->getValue("GENERATOR_START_CAP",&rval,g_id)) {
01130           data->addValue("GENERATOR_START_CAP", uc_data[i].start_cap, g_id);
01131         } else {
01132           data->setValue("GENERATOR_START_CAP", uc_data[i].start_cap, g_id);
01133         }
01134 
01135         if (!data->getValue("GENERATOR_SHUT_CAP",&rval,g_id)) {
01136           data->addValue("GENERATOR_SHUT_CAP", uc_data[i].shut_cap, g_id);
01137         } else {
01138           data->setValue("GENERATOR_SHUT_CAP", uc_data[i].shut_cap, g_id);
01139         }
01140       }
01141     }
01142 
01143     // Utility function to check if device is on a generator
01144     bool onGenerator(std::string &device) {
01145       bool ret = false;
01146       if (device == "GENCLS" || device == "GENSAL" || device == "GENROU" ||
01147           device == "WSIEG1" || device == "EXDC1" || device == "EXDC2" ||
01148           device == "ESST1A" || device == "ESST4B" || device == "GGOV1" ||
01149           device == "WSHYGP" || device == "PSSSIM") {
01150         ret = true;
01151       }
01152       return ret;
01153     }
01154 
01155     // Utility function to check if device is on a bus
01156     bool onBus(std::string &device) {
01157       bool ret = false;
01158       if (device == "LVSHBL" || device == "FRQTPAT") {
01159         ret = true;
01160       }
01161       return ret;
01162     }
01163 
01164     // Utility function to check if device is on a branch
01165     bool onBranch(std::string &device) {
01166       bool ret = false;
01167       if (device == "DISTR1") {
01168         ret = true;
01169       }
01170       return ret;
01171     }
01172 
01173     // Utility function to check if parameters describe a load
01174     bool onLoad(std::string &device) {
01175       bool ret = false;
01176       if (device == "CIM6BL" || device == "USRLOD" ||
01177           device == "IEELBL") {
01178         ret = true;
01179       }
01180       return ret;
01181     }
01182 
01183 
01184     // Extract extension from file name and convert it to lower case
01185     std::string getExtension(const std::string file)
01186     {
01187       std::string ret;
01188       std::string line = file;
01189       int ntok1 = line.find('.',0);
01190       if (ntok1 == std::string::npos) return ret;
01191       int nsav = ntok1;
01192       while(ntok1 != std::string::npos) {
01193         ntok1 = line.find('.',ntok1+1);
01194         if (ntok1 != std::string::npos) nsav=ntok1;
01195       }
01196       ntok1 = nsav;
01197       ntok1++;
01198       int ntok2 = line.find(' ',ntok1);
01199       if (ntok2 == std::string::npos)
01200         ntok2 = line.size();
01201       // get extension
01202       ret = line.substr(ntok1,ntok2-ntok1);
01203       // convert all characters to lower case 
01204       int size = ret.size();
01205       int i;
01206       for (i=0; i<size; i++) {
01207         if (isalpha(ret[i])) {
01208           ret[i] = tolower(ret[i]);
01209         }
01210       }
01211       return ret;
01212     }
01213 
01214     void find_ds_par(std::ifstream & input)
01215     {
01216       std::string          line;
01217       gridpack::component::DataCollection *data;
01218       while(std::getline(input,line)) {
01219         // Check to see if line is blank
01220         int idx = line.find_first_not_of(' ');
01221         if (idx == std::string::npos) continue;
01222 
01223         std::string record = line;
01224         idx = line.find('/');
01225         while (idx == std::string::npos) {
01226           std::getline(input,line);
01227           idx = line.find('/');
01228           record.append(line);
01229         }
01230         idx = record.find('/');
01231         if (idx != std::string::npos) record.erase(idx,record.length()-idx);
01232         std::vector<std::string>  split_line;
01233         boost::split(split_line, record, boost::algorithm::is_any_of(","),
01234             boost::token_compress_on);
01235 
01236         std::string sval;
01237         // MODEL TYPE              "MODEL"                  string
01238         gridpack::utility::StringUtils util;
01239         sval = util.trimQuotes(split_line[1]);
01240         util.toUpper(sval);
01241 
01242         if (onGenerator(sval)) {
01243           // GENERATOR_BUSNUMBER               "I"                   integer
01244           int l_idx, o_idx;
01245           o_idx = atoi(split_line[0].c_str());
01246 #ifdef OLD_MAP
01247           std::map<int, int>::iterator it;
01248 #else
01249           boost::unordered_map<int, int>::iterator it;
01250 #endif
01251           it = p_busMap->find(o_idx);
01252           if (it != p_busMap->end()) {
01253             l_idx = it->second;
01254           } else {
01255             continue;
01256           }
01257           data = dynamic_cast<gridpack::component::DataCollection*>
01258             (p_network->getBusData(l_idx).get());
01259 
01260           // Find out how many generators are already on bus
01261           int ngen = 0;
01262           data->getValue(GENERATOR_NUMBER, &ngen);
01263           // Identify index of generator to which this data applies
01264           int g_id = -1;
01265           if (ngen > 0) {
01266             // Clean up 2 character tag for generator ID
01267             std::string tag = util.clean2Char(split_line[2]);
01268             int i;
01269             for (i=0; i<ngen; i++) {
01270               std::string t_id;
01271               data->getValue(GENERATOR_ID,&t_id,i);
01272               if (tag == t_id) {
01273                 g_id = i;
01274                 break;
01275               }
01276             }
01277           }
01278 
01279           double rval;
01280           int ival;
01281           bool bval;
01282 
01283           if (g_id > -1) {
01284             if (sval == "GENCLS") {
01285               GenclsParser<gen_params> parser;
01286               parser.parse(split_line, data, g_id);
01287             } else if (sval == "GENSAL") {
01288               GensalParser<gen_params> parser;
01289               parser.parse(split_line, data, g_id);
01290             } else if (sval == "GENROU") {
01291               GenrouParser<gen_params> parser;
01292               parser.parse(split_line, data, g_id);
01293             } else if (sval == "WSIEG1") {
01294               Wsieg1Parser<gen_params> parser;
01295               parser.parse(split_line, data, g_id);
01296             } else if (sval == "EXDC1" || sval == "EXDC2") {
01297               Exdc1Parser<gen_params> parser;
01298               parser.parse(split_line, data, g_id);
01299             } else if (sval == "ESST1A") {
01300               Esst1aParser<gen_params> parser;
01301               parser.parse(split_line, data, g_id);
01302             } else if (sval == "ESST4A") {
01303               Esst4bParser<gen_params> parser;
01304               parser.parse(split_line, data, g_id);
01305             } else if (sval == "GGOV1") {
01306               Ggov1Parser<gen_params> parser;
01307               parser.parse(split_line, data, g_id);
01308             } else if (sval == "WSHYGP") {
01309               WshygpParser<gen_params> parser;
01310               parser.parse(split_line, data, g_id);
01311             } else if (sval == "PSSSIM") {
01312               PsssimParser<gen_params> parser;
01313               parser.parse(split_line, data, g_id);
01314             }
01315           }
01316         } else if (onBus(sval)) {
01317           int l_idx, o_idx;
01318           if (sval == "LVSHBL") {
01319             o_idx = atoi(split_line[0].c_str());
01320           } else if (sval == "FRQTPAT") {
01321             o_idx = atoi(split_line[3].c_str());
01322           }
01323 #ifdef OLD_MAP
01324           std::map<int, int>::iterator it;
01325 #else
01326           boost::unordered_map<int, int>::iterator it;
01327 #endif
01328           it = p_busMap->find(o_idx);
01329           if (it != p_busMap->end()) {
01330             l_idx = it->second;
01331           } else {
01332             continue;
01333           }
01334           data = dynamic_cast<gridpack::component::DataCollection*>
01335             (p_network->getBusData(l_idx).get());
01336           if (sval == "LVSHBL") {
01337             LvshblParser<gen_params> parser;
01338             parser.parse(split_line, data);
01339           } else if (sval == "FRQTPAT") {
01340             FrqtpatParser<gen_params> parser;
01341             parser.parse(split_line, data);
01342           }
01343         } else if (onLoad(sval)) {
01344           // Load bus number
01345           int l_idx, o_idx;
01346           o_idx = atoi(split_line[0].c_str());
01347 #ifdef OLD_MAP
01348           std::map<int, int>::iterator it;
01349 #else
01350           boost::unordered_map<int, int>::iterator it;
01351 #endif
01352           it = p_busMap->find(o_idx);
01353           if (it != p_busMap->end()) {
01354             l_idx = it->second;
01355           } else {
01356             continue;
01357           }
01358           data = dynamic_cast<gridpack::component::DataCollection*>
01359             (p_network->getBusData(l_idx).get());
01360 
01361           // Find out how many loads are already on bus
01362           int nload = 0;
01363           data->getValue(LOAD_NUMBER, &nload);
01364           // Identify index of load to which this data applies
01365           int l_id = -1;
01366           if (nload > 0) {
01367             // Clean up 2 character tag for load ID
01368             std::string tag = util.clean2Char(split_line[2]);
01369             int i;
01370             for (i=0; i<nload; i++) {
01371               std::string t_id;
01372               data->getValue(LOAD_ID,&t_id,i);
01373               if (tag == t_id) {
01374                 l_id = i;
01375                 break;
01376               }
01377             }
01378           }
01379           if (sval == "CIM6BL") {
01380             Cim6blParser<load_params> parser;
01381             parser.parse(split_line, data, l_id);
01382           } else if (sval == "IEELBL") {
01383             IeelblParser<load_params> parser;
01384             parser.parse(split_line, data, l_id);
01385           } else if (sval == "USRLOD") {
01386             std::string sdev;
01387             sdev = util.trimQuotes(split_line[3]);
01388             if (sdev == "ACMTBLU1") {
01389               Acmtblu1Parser<load_params> parser;
01390               parser.parse(split_line, data, l_id);
01391             } else if (sdev == "CMLDBLU1") {
01392               Cmldblu1Parser<load_params> parser;
01393               parser.parse(split_line, data, l_id);
01394             }
01395           }
01396         } else if (onBranch(sval)) {
01397           int l_idx, from_idx, to_idx;
01398           from_idx = atoi(split_line[0].c_str());
01399           to_idx = atoi(split_line[2].c_str());
01400           std::map<std::pair<int, int>, int>::iterator it;
01401           it = p_branchMap->find(std::pair<int,int>(from_idx,to_idx));
01402           if (it != p_branchMap->end()) {
01403             l_idx = it->second;
01404           } else {
01405             continue;
01406           }
01407           if (sval == "DISTR1") {
01408             Distr1Parser<gen_params> parser;
01409             parser.parse(split_line, data);
01410           }
01411         }
01412       }
01413     }
01414 
01415     // Parse file to construct lists of structs representing different devices.
01416     void find_ds_vector(std::ifstream & input, std::vector<gen_params> *gen_vector,
01417         std::vector<bus_relay_params> *bus_relay_vector,
01418         std::vector<branch_relay_params> *branch_relay_vector,
01419         std::vector<load_params> *load_vector)
01420     {
01421       std::string          line;
01422       gen_vector->clear();
01423       while(std::getline(input,line)) {
01424         // Check to see if line is blank
01425         int idx = line.find_first_not_of(' ');
01426         if (idx == std::string::npos) continue;
01427 
01428         std::string record = line;
01429         idx = line.find('/');
01430         while (idx == std::string::npos) {
01431           std::getline(input,line);
01432           idx = line.find('/');
01433           record.append(line);
01434         }
01435         idx = record.find('/');
01436         if (idx != std::string::npos) record.erase(idx,record.length()-idx);
01437         std::vector<std::string>  split_line;
01438         boost::split(split_line, record, boost::algorithm::is_any_of(","),
01439             boost::token_compress_on);
01440         std::string sval;
01441         gridpack::utility::StringUtils util;
01442         sval = util.trimQuotes(split_line[1]);
01443         util.toUpper(sval);
01444 
01445         if (onGenerator(sval)) {
01446           gen_params data;
01447 
01448           // GENERATOR_BUSNUMBER               "I"                   integer
01449           int o_idx;
01450           o_idx = atoi(split_line[0].c_str());
01451           data.bus_id = o_idx;
01452 
01453           // Clean up 2 character tag for generator ID
01454           std::string tag = util.clean2Char(split_line[2]);
01455           strcpy(data.gen_id, tag.c_str());
01456 
01457           double rval;
01458           int ival;
01459 
01460 
01461           // GENERATOR_MODEL              "MODEL"                  integer
01462           strcpy(data.model, sval.c_str());
01463 
01464           if (sval == "GENCLS") {
01465             GenclsParser<gen_params> parser;
01466             parser.store(split_line,data);
01467           } else if (sval == "GENSAL") {
01468             GensalParser<gen_params> parser;
01469             parser.store(split_line,data);
01470           } else if (sval == "GENROU") {
01471             GenrouParser<gen_params> parser;
01472             parser.store(split_line,data);
01473           } else if (sval == "WSIEG1") {
01474             Wsieg1Parser<gen_params> parser;
01475             parser.store(split_line,data);
01476           } else if (sval == "EXDC1" || sval == "EXDC2") {
01477             Exdc1Parser<gen_params> parser;
01478             parser.store(split_line,data);
01479           } else if (sval == "ESST1A") {
01480             Esst1aParser<gen_params> parser;
01481             parser.store(split_line,data);
01482           } else if (sval == "ESST4B") {
01483             Esst4bParser<gen_params> parser;
01484             parser.store(split_line,data);
01485           } else if (sval == "GGOV1") {
01486             Ggov1Parser<gen_params> parser;
01487             parser.store(split_line,data);
01488           } else if (sval == "WSHYGP") {
01489             WshygpParser<gen_params> parser;
01490             parser.store(split_line,data);
01491           } else if (sval == "PSSSIM") {
01492             PsssimParser<gen_params> parser;
01493             parser.store(split_line,data);
01494           }
01495           gen_vector->push_back(data);
01496         } else if (onBus(sval)) {
01497 
01498           // RELAY_BUSNUMBER               "I"                   integer
01499           int o_idx;
01500           if (sval == "LVSHBL") {
01501             bus_relay_params data;
01502             o_idx = atoi(split_line[0].c_str());
01503             data.bus_id = o_idx;
01504             LvshblParser<bus_relay_params> parser;
01505             parser.store(split_line,data);
01506             bus_relay_vector->push_back(data);
01507           } else if (sval == "FRQTPAT") {
01508             bus_relay_params data;
01509             o_idx = atoi(split_line[3].c_str());
01510             data.bus_id = o_idx;
01511             FrqtpatParser<bus_relay_params> parser;
01512             parser.store(split_line,data);
01513             bus_relay_vector->push_back(data);
01514           }
01515         } else if (onLoad(sval)) {
01516           // ID of bus that owns load
01517           load_params data;
01518           int o_idx = atoi(split_line[0].c_str());
01519           data.bus_id = o_idx;
01520 
01521           // Clean up 2 character tag for load ID
01522           std::string tag = util.clean2Char(split_line[2]);
01523           strcpy(data.id, tag.c_str());
01524           if (sval == "CIM6BL") {
01525             Cim6blParser<load_params> parser;
01526             parser.store(split_line,data);
01527           } else if (sval == "IEELBL") {
01528             IeelblParser<load_params> parser;
01529             parser.store(split_line,data);
01530           } else if (sval == "USRLOD") {
01531             std::string sdev;
01532             sdev = util.trimQuotes(split_line[3]);
01533             if (sdev == "ACMTBLU1") {
01534               Acmtblu1Parser<load_params> parser;
01535               parser.store(split_line,data);
01536             } else if (sdev == "CMLDBLU1") {
01537               Cmldblu1Parser<load_params> parser;
01538               parser.store(split_line,data);
01539             }
01540           }
01541           load_vector->push_back(data);
01542         } else if (onBranch(sval)) {
01543           branch_relay_params data;
01544 
01545           int from_idx, to_idx;
01546           if (sval == "DISTR1") {
01547             from_idx = atoi(split_line[0].c_str());
01548             to_idx = atoi(split_line[3].c_str());
01549             data.from_bus = from_idx;
01550             data.to_bus = to_idx;
01551             Distr1Parser<branch_relay_params> parser;
01552             parser.store(split_line,data);
01553           }
01554           branch_relay_vector->push_back(data);
01555         }
01556       }
01557     }
01558 
01559     void find_uc_vector(std::ifstream & input, std::vector<uc_params> *uc_vector)
01560     {
01561       std::string          line;
01562       uc_vector->clear();
01563       // Ignore first line containing header information
01564       std::getline(input,line);
01565       while(std::getline(input,line)) {
01566         std::vector<std::string>  split_line;
01567         boost::split(split_line, line, boost::algorithm::is_any_of(","),
01568             boost::token_compress_on);
01569 
01570         uc_params data;
01571 
01572         int nstr = split_line.size();
01573         if (nstr > 1) {
01574           data.type = atoi(split_line[1].c_str());
01575         }
01576         if (nstr > 2) {
01577           data.init_level = atof(split_line[2].c_str());
01578         }
01579         if (nstr > 3) {
01580           data.min_gen = atof(split_line[3].c_str());
01581         }
01582         if (nstr > 4) {
01583           data.max_gen = atof(split_line[4].c_str());
01584         }
01585         if (nstr > 5) {
01586           data.max_oper = atof(split_line[5].c_str());
01587         }
01588         if (nstr > 6) {
01589           data.min_up = atof(split_line[6].c_str());
01590         }
01591         if (nstr > 7) {
01592           data.min_down = atof(split_line[7].c_str());
01593         }
01594         if (nstr > 8) {
01595           data.ramp_up = atof(split_line[8].c_str());
01596         }
01597         if (nstr > 9) {
01598           data.ramp_down = atof(split_line[9].c_str());
01599         }
01600         if (nstr > 10) {
01601           data.start_up = atof(split_line[10].c_str());
01602         }
01603         if (nstr > 11) {
01604           data.const_cost = atof(split_line[11].c_str());
01605         }
01606         if (nstr > 12) {
01607           data.lin_cost = atof(split_line[12].c_str());
01608         }
01609         if (nstr > 13) {
01610           data.co_2_cost = atof(split_line[13].c_str());
01611         }
01612         if (nstr > 14) {
01613           data.init_prd = atof(split_line[14].c_str());
01614         }
01615         if (nstr > 15) {
01616           data.start_cap = atof(split_line[15].c_str());
01617         }
01618         if (nstr > 16) {
01619           data.shut_cap = atof(split_line[16].c_str());
01620         }
01621         if (nstr > 17) {
01622           data.bus_id = atoi(split_line[17].c_str());
01623         }
01624         if (nstr > 18) {
01625           // Clean up 2 character tag for generator ID
01626           gridpack::utility::StringUtils util;
01627           std::string tag = util.clean2Char(split_line[18]);
01628           strcpy(data.gen_id, tag.c_str());
01629         }
01630         uc_vector->push_back(data);
01631       }
01632     }
01633 
01634     /** Store pointer to bus and branch maps
01635      * @param busMap pointer to map between PTI and local indices
01636      * @param branchMap pointer to map between PTI bus pairs and local branch
01637      *        indices
01638      */
01639     void setMaps(std::map<int,int> *busMap,
01640                  std::map<std::pair<int, int>, int> *branchMap)
01641     {
01642       p_busMap = busMap;
01643       p_branchMap = branchMap;
01644     }
01645 
01646     /**
01647      * Remove comment from string (all text after a single '/' character)
01648      * @param string line of text to be cleaned
01649      */
01650     void cleanComment(std::string &string)
01651     {
01652       int idx = string.find_first_of('/',0);
01653       if (idx != std::string::npos) {
01654         int len = string.length()-idx;
01655         string.erase(idx,len);
01656       }
01657     }
01658 
01659     /**
01660      * Check to see if string is blank
01661      * @return true if no non-blank characters are found
01662      */
01663     bool isBlank(std::string string)
01664     {
01665       int idx = string.find_first_not_of(' ',0);
01666       if (idx != std::string::npos) return false;
01667       return true;
01668     }
01669 
01670     /* ************************************************************************
01671      **************************************************************************
01672      ***** OBJECT DATA
01673      **************************************************************************
01674      *********************************************************************** */
01675   private:
01676     boost::shared_ptr<_network> p_network;
01677 
01678     gridpack::utility::CoarseTimer *p_timer;
01679 
01680     // Map of PTI indices to index in p_busData
01681     std::map<int,int> *p_busMap;
01682     // Map of PTI index pair to index in p_branchData
01683     std::map<std::pair<int, int>, int> *p_branchMap;
01684 
01685     /**
01686      * Data collection object associated with network as a whole
01687      */
01688     boost::shared_ptr<gridpack::component::DataCollection> p_network_data;
01689 }; /* end of PTI base parser */
01690 
01691 } /* namespace parser */
01692 } /* namespace gridpack */
01693 
01694 #endif /* BASEPTIPARSER_HPP_ */